package com.example.util;
import java.util.List;

/**
 * @author AaronF
 * 字符串工具类
 * 提供了简单的字符串处理、拼接、判断等操作
 */
public class StringUtil {

    /**
     * 将字符串集合整合成一个字符串
     * @param list 字符串集合
     * @param delimiter 分隔符 如果为空则默认使用逗号
     * @return 如果集合为空 则返回空字符串
     */
    public static String transferListToString(List<String> list, String delimiter) {
        //判断集合是否为空
        if (list == null || list.size() == 0) {
            return "";
        }
        //如果分隔符为空则使用,代替
        delimiter = isEmpty(delimiter) ? "," : delimiter;
        StringBuilder sb = new StringBuilder();
        for (String str : list) {
            sb.append(str).append(delimiter);
        }
        //删除多余的分隔符
        sb.delete(sb.length() - delimiter.length(), sb.length());
        return sb.toString();
    }

    /**
     * 判断字符串是否对称
     *
     * @param str 需要判断的字符串
     * @return true即对称 false即不对称
     */
    public static boolean isSymmetrical(String str) {
        return new StringBuffer(str).reverse().toString().equals(str);
    }

    /**
     * 替换字符串操作
     * 讲源字符串两个索引之间的子字符串替换成目标字符串
     *
     * @param srcStr    原字符串
     * @param preIndex  替换位置前下标
     * @param lastIndex 替换位置后下标
     * @param tarStr    替换的字符串
     * @return 替换后的新字符串 如果输入非法则将原字符串返回
     */
    public static String replaceStr(String srcStr, int preIndex, int lastIndex, String tarStr) {
        if (preIndex < 0 || lastIndex > srcStr.length() - 1 || lastIndex < preIndex) {
            System.out.println("非法输入");
            return srcStr;
        }
        //源字符串字符数组
        char[] srcChars = srcStr.toCharArray();
        //新字符串的长度
        int newCharsLength = srcChars.length + tarStr.length() - (lastIndex - preIndex + 1);
        //新字符串数组
        char[] tarChars = new char[newCharsLength];
        //指向数组当前赋值位置的指针
        int index = 0;
        //给新字符数组赋值
        //替换部分前半段
        for (int i = 0; i < preIndex; i++) {
            tarChars[index++] = srcChars[i];
        }
        //插入替换的部分
        for (int i = 0; i < tarStr.length(); i++) {
            tarChars[index++] = tarStr.charAt(i);
        }
        //替换部分后半段
        for (int i = lastIndex + 1; i < srcChars.length; i++) {
            tarChars[index++] = srcChars[i];
        }
        return new String(tarChars);
    }

    /**
     * 统计目标字符串在源字符串中出现的次数
     * 如：源字符串 absjabsjiab 目标字符串 ab
     * 出现次数为3次
     *
     * @param srcStr 源字符串
     * @param tarStr 目标字符串
     * @return 出现的次数
     */
    public static int tarAppearSrc(String srcStr, String tarStr) {
        //判断输入是否合法
        if (isEmpty(srcStr) || isEmpty(tarStr)) {
            return 0;
        }
        //获取目标字符串开头字符
        char c = tarStr.charAt(0);
        //计数器
        int num = 0;
        //旗帜
        boolean flag;
        //逐个字符判断与目标字符串重复的开头
        //暴力循环
        for (int i = 0; i < srcStr.length(); i++) {
            flag = true;
            //判断是否首部相等 并且剩余字符串是否大于目标字符串
            if (srcStr.charAt(i) == c && (srcStr.length() - i) >= tarStr.length()) {
                //判断后续字符是否相等
                for (int j = 1; j < tarStr.length(); j++) {
                    if (tarStr.charAt(j) != srcStr.charAt(i + j)) {
                        flag = false;
                        break;
                    }
                }
                //如果匹配则加一
                if (flag) {
                    num++;
                }
            }
        }
        return num;
    }

    /**
     * 判断字符串是否为空
     * 注意：如果传进来的字符串全为空格也会判定为空
     *
     * @param str 需要判断的字符串
     * @return true即为空 false即不是
     */
    public static boolean isEmpty(String str) {
        return str == null || str.trim().length() == 0;
    }

    /**
     * 该方法用于检验字符串是否满足长度要求(左右皆为闭区间)
     *
     * @param min         最小值
     * @param max         最大值
     * @param stringArray 需要判断的字符串数组
     * @return
     */
    public static boolean checkLength(int min, int max, String... stringArray) {
        if (min < 0 || max < min) {
            System.out.println("非法输入");
            return false;
        }
        for (String s : stringArray) {
            if (s.length() < min || s.length() > max) {
                return false;
            }
        }
        return true;
    }

    /**
     * 该方法用于检验字符串是否满足长度要求(左右皆为闭区间)
     *
     * @param min         最小值
     * @param max         最大值
     * @param stringArray 需要判断的字符串数组
     * @return
     */
    public static boolean checkLength(String min, String max, String... stringArray) {
        try {
            int minNum = Integer.parseInt(min);
            int maxNum = Integer.parseInt(max);
            return checkLength(minNum, maxNum, stringArray);
        } catch (Exception e) {
            System.out.println("输入不合法");
            return false;
        }
    }
}